// 封装集合类
function Set() {
  // 属性
  this.items = {};

  // 方法
  //   1.add方法
  Set.prototype.add = function (value) {
    //判断当前集合是否已经包含该元素
    if (this.has(value)) {
      return false;
    }
    //将元素添加到集合中
    this.items[value] = value;
    return true;
  };

  //  2. has方法
  Set.prototype.has = function (value) {
    return this.items.hasOwnProperty(value);
  };

  //3.remove 方法
  Set.prototype.remove = function (value) {
    //1.判断当前集合是否已经包含该元素
    if (!this.has(value)) {
      return false;
    }
    //2.将元素从属性中删除
    delete this.items[value];
    return true;
  };

  //4.clear方法
  Set.prototype.clear = function () {
    this.items = {};
  };

  //5.size 方法
  Set.prototype.size = function () {
    return Object.keys(this.items).length;
  };

  //6.values 获取集合中所有的值
  Set.prototype.values = function () {
    return Object.keys(this.items);
  };

  //   集合之间的操作
  // 1.并集
  Set.prototype.union = function (otherSet) {
    //1，创建新的集合
    let unionSet = new Set();
    //2，将A集合中所有的元素添加到新集合中
    let values = this.values();

    for (let i = 0; i < values.length; i++) {
      unionSet.add(values[i]);
    }
    //3，取出B集合中的元素，判断是否需要加到新集合
    values = otherSet.values();
    for (let i = 0; i < values.length; i++) {
      unionSet.add(values[i]);
    }
    return unionSet;
  };

  //2.交集
  Set.prototype.intersection = function (otherSet) {
    //1，创建新的集合
    let intersectionSet = new Set();

    //2，从A中取出一个个元素，判断是否同时存在于集合B中，存在放入新集合中
    let values = this.values();

    for (let i = 0; i < values.length; i++) {
      let item = values[i];
      if (otherSet.has(item)) {
        intersectionSet.add(item);
      }
    }
    return intersectionSet;
  };

  // 3.差集
  Set.prototype.difference = function (otherSet) {
    //1，创建新的集合
    let differenceSet = new Set();

    //2，从A中取出一个个元素，判断是否不存在于集合B中，不存在放入新集合中
    let values = this.values();

    for (let i = 0; i < values.length; i++) {
      let item = values[i];
      if (!otherSet.has(item)) {
        differenceSet.add(item);
      }
    }
    return differenceSet;
  };

  // 4.子集
  Set.prototype.subset = function (otherSet) {
    //this：集合A
    //otherSet：集合B
    // 遍历集合A中所有的元素，如果发现，集合A中的元素，在集合B中不存在，那么返回false
    // 如果遍历完了整个集合，依然没有返回false，那么返回true即可
    let values = this.values();
    for (let i = 0; i < values.length; i++) {
      if (!otherSet.has(values[i])) {
        return false;
      }
    }
    return true;
  };
}

// 测试集合之间的操作
let setA = new Set();
setA.add("AA");
setA.add("BB");
setA.add("CC");
let setB = new Set();
setB.add("BB");
setB.add("CC");
setB.add("DD");

let setC = new Set();
setC.add("AA");
setC.add("BB");
setC.add("CC");
setC.add("DD");

console.log(setA, setB, setC);

//并集
console.log("并集", setA.union(setB));

//交集
console.log("交集", setA.intersection(setB));

//差集
console.log("差集", setA.difference(setB));

//子集
console.log("子集", setA.subset(setC));
